﻿// See https://aka.ms/new-console-template for more information

using System;
using System.Security.Cryptography.X509Certificates;
using System.Threading.Tasks.Sources;
using System.Xml.Linq;

namespace DemoTest
{
    // 定义一个简单的委托
    public delegate void SimpleDelegate(string message);

    class Program
    {

        static void Main(string[] args)
        {
            Console.WriteLine("Hello, World!");

            Console.WriteLine("值类型如下：");

            Console.WriteLine("整型：");

            // int 有符号整型
            int age = 20;
            Console.WriteLine($"块哥今年{age}岁");
            // byte 无符号整型 范围0-255
            byte data = 255;
            byte data1 = 0;
            // byte data2 = 256;不能超过255
            Console.WriteLine($"{data}");
            Console.WriteLine($"{data1}");
            // Console.WriteLine($"{data2}");
            // long 64位有符号整数，范围 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807。
            long longData = -1234567890123456789L; //这里L作为long类型的后缀 标识
            long longData1 = 123;
            long longData2 = 123L;
            long longData3 = 922332036854775808L;
            Console.WriteLine($"{longData}");
            Console.WriteLine($"{longData1}");
            Console.WriteLine($"{longData2}");
            Console.WriteLine($"{longData3}");
            // ulong 64位有符号整数，范围 0 到 9,223,372,036,854,775,807。和long类型的区别就是  ulong只能为正数和0
            ulong ulongData = 1234567890123456789UL;
            // ulong ulongData1 = -1234567890123456789UL;
            Console.WriteLine($"{ulongData}");

            Console.WriteLine("浮点型：");

            // float 32位单精度浮点数，范围 -3.402823E+38 到 3.402823E+38   大约能提供 7 个十进制数字的精度。这意味着在小数点后大约 7 位是可靠的
            float floatData = 123.456F; // float类型的后缀是F
            // double 64位双精度浮点数，范围 -1.79769313486232E+308 到 1.79769313486232E+308  大约能提供 15-17 个十进制数字的精度。
            double doubleData = 458.4685465156156156595665565665466656541565666445646464585648995595959745979641597591579159759159712975915927648D; // double类型的后缀是D
            // decimal 128位高精度浮点数（ 精确小数型），范围 -79,228,162,514,264,337,593,543,950,335 到 79,228,162,514,264,337,593,543,950,335。大约能提供 28-29 个十进制数字的精度。 
            decimal decimalData = 12345.1234567890123456789012345678901234567890M; // decimal类型的后缀是M 

            // 布尔类型 用于存储布尔值，只能是 true 或 false。
            Console.WriteLine("布尔类型：");
            bool boolData = true;
            bool boolData1 = false;
            Console.WriteLine($"{boolData},{boolData1}");

            // char 字符类型 用于存储单个字符。 
            Console.WriteLine("字符类型：");
            char charData = 'A';
            // char charData1 = 'AB';
            Console.WriteLine($"{charData}");

            Console.WriteLine("枚举类型：");
            Console.WriteLine($"Male = {(int)Gender.Male}");
            Console.WriteLine($"Female = {(int)Gender.Female}");
            // 结构体 用于定义一组相关的数据。 自定义的值类型，用于封装数据和相关功能。当一个类型主要用于存储少量相关数据，并且这些数据在复制时应进行完整复制而不是引用复制时，适合使用 struct
            Console.WriteLine("结构体：");

            // 创建一个结构体实例
            Person person = new Person(150, 250);
            person.Display();

            Console.WriteLine("引用类型如下：");


            Console.WriteLine("类：");

            //类 所有自定义类都是引用类型。引用类型存储的是对象的引用，而不是对象本身。引用类型的变量存储的是对实际数据的引用，而不是数据本身。引用类型包括类、接口、委托和数组等。

            // 创建一个类实例
            Hb001 hb = new Hb001();
            // 调用方法
            hb.Introduce();
            //赋值
            hb.Name = "块哥";
            hb.Age = 20;
            hb.Introduce();




            Console.WriteLine("接口：");


            //接口 定义了一组方法和属性的契约，任何实现该接口的类都必须提供这些方法和属性的具体实现。接口本身不包含任何实现代码，只定义了方法的签名。
            // 定义一个接口
            IAnimal animal = new Dog();
            animal.Speak();

            //数组
            Console.WriteLine("数组：");
            // 数组 是一种数据结构，用于存储多个相同类型的元素。数组的大小在创建时确定，并且不能更改。数组可以是值类型或引用类型。
            // 创建一个整数数组
            int[] numbers = new int[5];
            // 初始化数组
            numbers[0] = 1;
            numbers[1] = 2;
            numbers[2] = 3;
            numbers[3] = 4;
            numbers[4] = 5;
            Console.WriteLine($"数组：{numbers[0]},{numbers[2]},{numbers[1]},{numbers[4]}");

            //字符串
            string hbname = "海豹001";
            Console.WriteLine($"字符串{hbname}");

            //object 可以存储任何类型的对象，包括值类型和引用类型。object 是所有类型的基类，所有类型都可以隐式转换为 object 类型。
            object o1 = 20;
            object o2 = "我是毛毛";
            object o3 = 2.5;

            Console.WriteLine($"object引用对象   ：  " +
                $"你们好，{o2},我今年{o1}岁，我的特长是在王者峡谷当网络喷子，我已经联系了{o3}年");




            Console.ReadKey();
        }
    }

    // 创建一个结构体
    public struct Person
    {
        private byte hb;
        private int Age;

        public Person(int a = 1, int b = 255)
        {
            hb = (byte)a; // Ensure 'hb' is assigned
            Age = b;      // Ensure 'Age' is assigned
        }

        public void Display()
        {
            Console.WriteLine($"{hb}, {Age}");
        }
    }

    // 枚举类型 用于定义一组常量。
    enum Gender
    {
        Male = 0,
        Female = 1
    }
    //创建一个自定义类
    public class Hb001
    {
        public string Name { get; set; }
        public int Age { get; set; }

        public Hb001(string name = "海豹", int age = 18)
        {
            Name = name;
            Age = age;
        }

        public void Introduce()
        {
            Console.WriteLine($"大家好，我叫 {Name}，今年 {Age} 岁。");
        }
    }
    //创建一个接口
    public interface IAnimal
    {
        void Speak();
    }
    //实现接口
    public class Dog : IAnimal
    {
        public void Speak()
        {
            Console.WriteLine("接口的调用");
        }
    }



}
